@portabletext/markdown 1.4.6 → 1.5.0

package/README.md

@@ -72,14 +72,14 @@ const markdown = portableTextToMarkdown([
 | Unordered lists  | ✅                       | ✅                       |
 | Task lists       | ✅\*                     | ✅\*                     |
 | Nested lists     | ✅                       | ✅                       |
-| Code blocks      | ✅                       | ✅\*                     |
-| Horizontal rules | ✅                       | ✅\*                     |
-| Images           | ✅                       | ✅\*                     |
-| Tables           | ✅\*                     | ✅\*                     |
-| HTML blocks      | ✅                       | ✅\*                     |
-| Callouts         | ✅\*                     | ✅\*                     |
+| Code blocks      | ✅                       | ✅                       |
+| Horizontal rules | ✅                       | ✅                       |
+| Images           | ✅                       | ✅                       |
+| Tables           | ✅                       | ✅                       |
+| HTML blocks      | ✅                       | ✅                       |
+| Callouts         | ✅                       | ✅                       |
 
-\* Requires custom configuration (see usage below)
+\* Requires a schema that declares a `task` list; the default schema does not (see [GFM task lists](#configuring-matchers) below)
 
 ## Usage
 
@@ -162,14 +162,14 @@ Out of the box, the library includes sensible defaults for both. Customize them
 
 The default schema includes the following definitions:
 
-| Type            | Values                                                                                                                                                                                                                                  |
-| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `styles`        | `'normal'`, `'h1'`, `'h2'`, `'h3'`, `'h4'`, `'h5'`, `'h6'`, `'blockquote'`                                                                                                                                                              |
-| `lists`         | `'number'`, `'bullet'`                                                                                                                                                                                                                  |
-| `decorators`    | `'strong'`, `'em'`, `'code'`, `'strike-through'`                                                                                                                                                                                        |
-| `annotations`   | `'link'` (fields: `'href'`, `'title'`)                                                                                                                                                                                                  |
-| `blockObjects`  | `'code'` (fields: `'language'`, `'code'`), `'image'` (fields: `'src'`, `'alt'`, `'title'`), `'horizontal-rule'`, `'html'` (fields: `'html'`), `'table'` (fields: `'headerRows'`, `'rows'`), `'callout'` (fields: `'tone'`, `'content'`) |
-| `inlineObjects` | `'image'` (fields: `'src'`, `'alt'`, `'title'`)                                                                                                                                                                                         |
+| Type            | Values                                                                                                                                                                                                                                                                       |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `styles`        | `'normal'`, `'h1'`, `'h2'`, `'h3'`, `'h4'`, `'h5'`, `'h6'`, `'blockquote'`                                                                                                                                                                                                   |
+| `lists`         | `'number'`, `'bullet'`                                                                                                                                                                                                                                                       |
+| `decorators`    | `'strong'`, `'em'`, `'code'`, `'strike-through'`                                                                                                                                                                                                                             |
+| `annotations`   | `'link'` (fields: `'href'`, `'title'`)                                                                                                                                                                                                                                       |
+| `blockObjects`  | `'code'` (fields: `'language'`, `'code'`), `'image'` (fields: `'src'`, `'alt'`, `'title'`), `'horizontal-rule'`, `'html'` (fields: `'html'`), `'table'` (the canonical nested shape, see [Default behavior](#default-behavior)), `'callout'` (fields: `'tone'`, `'content'`) |
+| `inlineObjects` | `'image'` (fields: `'src'`, `'alt'`, `'title'`)                                                                                                                                                                                                                              |
 
 To use a custom Schema, import `compileSchema` and `defineSchema` from `@portabletext/schema`:
 
@@ -218,8 +218,38 @@ Matchers map Markdown concepts to Portable Text types defined in the Schema. Eac
 |            | `image`          | `![alt](src)`           | `'image'`           |
 |            | `html`           | HTML blocks             | `'html'`            |
 |            | `callout`        | `> [!NOTE]`, etc.       | `'callout'`         |
-|            | `blockquote`     | `>` blockquotes         | `'blockquote'`      |
-|            | `list`           | `- ` or `1. ` lists     | `'list'`            |
+|            | `table`          | GFM pipe tables         | `'table'`           |
+|            | `blockquote`\*   | `>` blockquotes         | `'blockquote'`      |
+|            | `list`\*         | `- ` or `1. ` lists     | `'list'`            |
+
+\* Opt-in, not registered by default: `blockquote` and `list` map onto structural container shapes, and the parser only produces those shapes when you register the matcher (see [Configuring matchers](#configuring-matchers)). Without them, blockquotes and lists parse to flat text blocks, which is the standard Portable Text shape for both, not a degraded fallback.
+
+#### Default behavior
+
+**Tables** (GFM pipe tables) convert by default, in the canonical shape `@portabletext/plugin-table` expects: a `table` block object (`headerRows`, `rows`), each row a `row` object (`cells`), each cell a `cell` object (`value`, an array of Portable Text blocks; a cell holding a single image becomes a standalone block-level `image` object instead of a text block wrapping it). `alignment` is a `@portabletext/markdown` extension field; `@portabletext/plugin-table` ignores it. This needs no configuration when the schema declares a `table` block object with a `rows` field (see `blockObjects` above). A schema whose `table` doesn't declare `rows`, or that doesn't declare `table` at all, produces no table object at all: the table's cell content flattens into top-level blocks, in reading order, and the table structure is discarded.
+
+**Images** are handled based on context:
+
+- Standalone images (a paragraph containing only an image) become block-level `'image'` objects
+- Images mixed with text become inline `'image'` objects (if the schema includes `'image'` in `inlineObjects`)
+- If neither is supported, falls back to plain text: `![alt](src)`
+
+The default image matcher requires the schema type to have a `'src'` field. If your `'image'` type doesn't include this field, the matcher returns `undefined`.
+
+**Code** is handled based on the Markdown syntax:
+
+- Fenced code blocks (` ``` `) become `'code'` block objects with `language` and `code` fields
+- Inline code (`` ` ``) applies the `'code'` decorator to a span
+
+The default code block matcher requires the schema type to have a `'code'` field. If your `'code'` type doesn't include this field, the matcher returns `undefined`.
+
+**Links** support optional titles using `[text](url "title")` syntax. The title is captured in the `'title'` field of the `'link'` annotation.
+
+**Nested lists** are handled automatically. Each list item block includes a `level` property indicating its nesting depth (1 for top-level, 2 for nested, etc.).
+
+**HTML blocks** (like `<div>...</div>`) become `'html'` block objects with the raw HTML in the `'html'` field. Inline HTML is controlled by the `html.inline` option.
+
+**Callouts** use the `> [!TYPE]` syntax (GFM alerts) where `TYPE` is one of `NOTE`, `TIP`, `WARNING`, `CAUTION`, or `IMPORTANT`. They become `'callout'` block objects with a `'tone'` field (the lowercased type name) and a `'content'` field (an array of Portable Text blocks). When the schema doesn't include a `'callout'` block object, the content falls back to blockquote-styled blocks.
 
 #### Configuring matchers
 
@@ -246,7 +276,7 @@ markdownToPortableText(markdown, {
 
 > **Note:** Checking if the type exists in the schema isn't required, but it's good practice. Returning `undefined` gracefully skips unsupported types.
 
-**Table matcher:** Markdown tables are parsed but there's no default matcher. Provide one if your schema includes tables:
+**Table matcher:** GFM pipe tables convert by default (see [Default behavior](#default-behavior)). Provide your own matcher to map onto a differently-shaped `table` type:
 
 ```ts
 markdownToPortableText(markdown, {
@@ -348,31 +378,6 @@ Matchers receive:
 
 Return `undefined` to skip the element (e.g., if the type isn't in the schema).
 
-#### Default behavior for images and code
-
-**Images** are handled based on context:
-
-- Standalone images (a paragraph containing only an image) become block-level `'image'` objects
-- Images mixed with text become inline `'image'` objects (if the schema includes `'image'` in `inlineObjects`)
-- If neither is supported, falls back to plain text: `![alt](src)`
-
-The default image matcher requires the schema type to have a `'src'` field. If your `'image'` type doesn't include this field, the matcher returns `undefined`.
-
-**Code** is handled based on the Markdown syntax:
-
-- Fenced code blocks (` ``` `) become `'code'` block objects with `language` and `code` fields
-- Inline code (`` ` ``) applies the `'code'` decorator to a span
-
-The default code block matcher requires the schema type to have a `'code'` field. If your `'code'` type doesn't include this field, the matcher returns `undefined`.
-
-**Links** support optional titles using `[text](url "title")` syntax. The title is captured in the `'title'` field of the `'link'` annotation.
-
-**Nested lists** are handled automatically. Each list item block includes a `level` property indicating its nesting depth (1 for top-level, 2 for nested, etc.).
-
-**HTML blocks** (like `<div>...</div>`) become `'html'` block objects with the raw HTML in the `'html'` field. Inline HTML is controlled by the `html.inline` option.
-
-**Callouts** use the `> [!TYPE]` syntax (GFM alerts) where `TYPE` is one of `NOTE`, `TIP`, `WARNING`, `CAUTION`, or `IMPORTANT`. They become `'callout'` block objects with a `'tone'` field (the lowercased type name) and a `'content'` field (an array of Portable Text blocks). When the schema doesn't include a `'callout'` block object, the content falls back to blockquote-styled blocks.
-
 #### Other options
 
 ```ts
@@ -449,34 +454,42 @@ The conversion is driven by **Renderers**: functions that render Portable Text e
 
 #### Default renderers
 
-| Group               | Renderer         | Renders                           | Output                   |
-| ------------------- | ---------------- | --------------------------------- | ------------------------ |
-| `block`             | `normal`         | Paragraphs                        | `{children}`             |
-|                     | `h1`–`h6`        | Headings                          | `# `–`###### `           |
-|                     | `blockquote`     | Blockquotes                       | `> {children}`           |
-| `marks`             | `strong`         | Bold text                         | `**{children}**`         |
-|                     | `em`             | Italic text                       | `_{children}_`           |
-|                     | `code`           | Inline code                       | `` `{children}` ``       |
-|                     | `underline`      | Underlined text                   | `<u>{children}</u>`      |
-|                     | `strike-through` | Strikethrough                     | `~~{children}~~`         |
-|                     | `link`           | Links                             | `[{children}](url)`      |
-| `listItem`          |                  | List items (bullet, number, task) | `- `, `1. `, or `- [x] ` |
-| `hardBreak`         |                  | Line breaks within blocks         | `  \n` (two spaces)      |
-| `blockSpacing`      |                  | Spacing between blocks            | `\n\n`, `\n`, `\n>\n`    |
-| `unknownType`       |                  | Unknown block types               | JSON code block          |
-| `unknownBlockStyle` |                  | Unknown block styles              | `{children}`             |
-| `unknownListItem`   |                  | Unknown list item types           | `- {children}`           |
-| `unknownMark`       |                  | Unknown marks                     | `{children}`             |
+| Group               | Renderer          | Renders                           | Output                   |
+| ------------------- | ----------------- | --------------------------------- | ------------------------ |
+| `types`             | `callout`         | `callout` block objects           | `> [!TYPE]\n> content`   |
+|                     | `code`            | `code` block objects              | Fenced code block        |
+|                     | `horizontal-rule` | `horizontal-rule` block objects   | `---`                    |
+|                     | `html`            | `html` block objects              | Raw HTML                 |
+|                     | `image`           | `image` block/inline objects      | `![alt](src "title")`    |
+|                     | `table`           | `table` block objects             | Markdown table           |
+| `block`             | `normal`          | Paragraphs                        | `{children}`             |
+|                     | `h1`–`h6`         | Headings                          | `# `–`###### `           |
+|                     | `blockquote`      | Blockquotes                       | `> {children}`           |
+| `marks`             | `strong`          | Bold text                         | `**{children}**`         |
+|                     | `em`              | Italic text                       | `_{children}_`           |
+|                     | `code`            | Inline code                       | `` `{children}` ``       |
+|                     | `underline`       | Underlined text                   | `<u>{children}</u>`      |
+|                     | `strike-through`  | Strikethrough                     | `~~{children}~~`         |
+|                     | `link`            | Links                             | `[{children}](url)`      |
+| `listItem`          |                   | List items (bullet, number, task) | `- `, `1. `, or `- [x] ` |
+| `hardBreak`         |                   | Line breaks within blocks         | `  \n` (two spaces)      |
+| `blockSpacing`      |                   | Spacing between blocks            | `\n\n`, `\n`, `\n>\n`    |
+| `unknownType`       |                   | Unknown block types               | JSON code block          |
+| `unknownBlockStyle` |                   | Unknown block styles              | `{children}`             |
+| `unknownListItem`   |                   | Unknown list item types           | `- {children}`           |
+| `unknownMark`       |                   | Unknown marks                     | `{children}`             |
 
 Unknown types render as JSON code blocks by default; unknown styles, list items, and marks pass through their children.
 
+The default type renderers are collision-safe: because the serializer dispatches on the `_type` name alone, `code`, `html`, `image`, `callout`, and `table` fall back to the `unknownType` renderer (a JSON code block) when a value doesn't match the shape their renderer expects (say, your own differently-shaped `code` type); `horizontal-rule` has no shape to check and always renders `---`. Register your own `types.<name>` renderer to override how any of them serialize, or to handle a same-named type of a different shape.
+
 > **Note:** The `underline` renderer is included for Portable Text that uses it, but there's no standard Markdown syntax for underline, so it renders as HTML.
 
 #### Configuring renderers
 
 Provide custom renderers to control how Portable Text renders to Markdown.
 
-**Custom type renderers:** Render custom block types (objects in the blocks array):
+**Custom type renderers:** Render custom block types (objects in the blocks array). A custom renderer under a default's name (see [Default renderers](#default-renderers)) replaces that default:
 
 ```ts
 portableTextToMarkdown(blocks, {
@@ -500,31 +513,19 @@ portableTextToMarkdown(blocks, {
 })
 ```
 
-**Built-in type renderers:** The library exports default renderers for common block types:
+**Built-in type renderers:** the library exports every built-in type renderer, in case you want to compose one into a different renderer or reuse it under a different type name. Two of them are exported but not registered by default: `DefaultBlockquoteObjectRenderer` and `DefaultListRenderer` render the structural container shapes (`types.blockquote`/`types.list` on the parser side) and stay opt-in, since the parser only produces those shapes when a matcher is registered for them:
 
 ```ts
 import {
   DefaultBlockquoteObjectRenderer,
-  DefaultCalloutRenderer,
-  DefaultCodeBlockRenderer,
-  DefaultHorizontalRuleRenderer,
-  DefaultHtmlRenderer,
-  DefaultImageRenderer,
   DefaultListRenderer,
-  DefaultTableRenderer,
   portableTextToMarkdown,
 } from '@portabletext/markdown'
 
 portableTextToMarkdown(blocks, {
   types: {
-    'blockquote': DefaultBlockquoteObjectRenderer,
-    'callout': DefaultCalloutRenderer,
-    'code': DefaultCodeBlockRenderer,
-    'horizontal-rule': DefaultHorizontalRuleRenderer,
-    'html': DefaultHtmlRenderer,
-    'image': DefaultImageRenderer,
-    'list': DefaultListRenderer,
-    'table': DefaultTableRenderer,
+    blockquote: DefaultBlockquoteObjectRenderer,
+    list: DefaultListRenderer,
   },
 })
 ```

package/dist/index.d.ts

@@ -268,6 +268,14 @@ interface PortableTextRendererOptions<T> {
    * Index of a list item
    */
   listIndex?: number | undefined;
+  /**
+   * How deeply the list item should be indented, starting at 0.
+   *
+   * This is not the same as the block's `level`. A list can start deeper than
+   * level 1, and can skip levels, neither of which Markdown can express, so each
+   * jump to a deeper level counts as a single step of nesting.
+   */
+  listDepth?: number | undefined;
   /**
    * Whether or not this node is "inline" - ie as a child of a text block,
    * alongside text spans, or a block in and of itself.
@@ -446,13 +454,13 @@ declare const DefaultImageRenderer: PortableTextTypeRenderer<{
 /**
  * Renders a Portable Text table block-object back to Markdown.
  *
- * The PT `headerRows` field decides the header. `headerRows === 0` is an
- * explicit headerless table: GFM has no headerless form, so an empty header
- * row is emitted and every row goes in the body (that empty header reads back
- * as `headerRows: 0` via `markdownToPortableText`). Any other value
- * (`undefined` or `>= 1`) promotes `rows[0]` to the header. GFM allows exactly
- * one header row, so header rows beyond the first flatten into the body,
- * lossy, but the extra rows stay on the Portable Text side.
+ * The PT `headerRows` field decides the header. Missing `headerRows` and
+ * `headerRows === 0` both render headerless: GFM has no headerless form, so
+ * an empty header row is emitted and every row goes in the body (that empty
+ * header reads back as `headerRows: 0` via `markdownToPortableText`).
+ * `headerRows >= 1` promotes `rows[0]` to the header. GFM allows exactly one
+ * header row, so header rows beyond the first flatten into the body, lossy,
+ * but the extra rows stay on the Portable Text side.
  *
  * Asymmetric tables (rows of varying cell counts) are widened to match
  * the row with the most cells. Narrower rows are padded with empty cells

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../node_modules/.pnpm/@portabletext+types@4.0.2/node_modules/@portabletext/types/dist/index.d.ts","../src/from-portable-text/renderers/block-spacing.ts","../src/from-portable-text/types.ts","../src/from-portable-text/portable-text-to-markdown.ts","../src/from-portable-text/renderers/hard-break.ts","../src/from-portable-text/renderers/list-item.ts","../src/from-portable-text/renderers/style.ts","../src/from-portable-text/renderers/marks.ts","../src/from-portable-text/renderers/type.ts","../src/to-portable-text/matchers.ts","../src/to-portable-text/markdown-to-portable-text.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../node_modules/.pnpm/@portabletext+types@4.0.2/node_modules/@portabletext/types/dist/index.d.ts","../src/from-portable-text/renderers/block-spacing.ts","../src/from-portable-text/types.ts","../src/from-portable-text/portable-text-to-markdown.ts","../src/from-portable-text/renderers/hard-break.ts","../src/from-portable-text/renderers/list-item.ts","../src/from-portable-text/renderers/style.ts","../src/from-portable-text/renderers/marks.ts","../src/from-portable-text/renderers/type.ts","../src/to-portable-text/matchers.ts","../src/to-portable-text/markdown-to-portable-text.ts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { compileSchema, defineSchema, isSpan, isTextBlock } from "@portabletext/schema";
+import { compileSchema, defineSchema, isSpan, isTextBlock, isTypedObject } from "@portabletext/schema";
 import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
 import { alert } from "@mdit/plugin-alert";
 import markdownit from "markdown-it";
@@ -24,57 +24,74 @@ function randomKey(length) {
 }
 const schema = compileSchema(defineSchema({}));
 /**
-* Builds a map of list item `_key`s to their index.
+* Builds a map of list item `_key`s to their index, and a map of list item
+* `_key`s to the depth they should be rendered at.
+*
+* The depth is not the same as the block's `level`. A list can start at a level
+* deeper than 1, and can skip levels, but Markdown has no way to express either:
+* indentation is relative to the list item above, and indenting a first item by
+* four spaces or more makes it a code block rather than a list. So each jump to a
+* deeper level counts as a single step of nesting, however many levels it spans.
 *
 * Mutates the blocks in place by adding a `_key` if necessary.
 */
 function buildListIndexMap(blocks) {
-	let levelIndexMaps = /* @__PURE__ */ new Map(), listIndexMap = /* @__PURE__ */ new Map(), previousListItem;
+	let levelIndexMaps = /* @__PURE__ */ new Map(), listIndexMap = /* @__PURE__ */ new Map(), listDepthMap = /* @__PURE__ */ new Map(), levelStack = [];
+	function depthOf(level) {
+		let deepest = levelStack.at(-1);
+		for (; deepest !== void 0 && deepest > level;) levelStack.pop(), deepest = levelStack.at(-1);
+		return deepest !== level && levelStack.push(level), levelStack.length - 1;
+	}
+	let previousListItem;
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		let block = blocks.at(blockIndex);
 		if (block === void 0) continue;
 		if (block._key ||= defaultKeyGenerator(), !isTextBlock({ schema }, block)) {
-			levelIndexMaps.clear(), previousListItem = void 0;
+			levelIndexMaps.clear(), previousListItem = void 0, levelStack = [];
 			continue;
 		}
 		if (block.listItem === void 0 || block.level === void 0) {
-			levelIndexMaps.clear(), previousListItem = void 0;
+			levelIndexMaps.clear(), previousListItem = void 0, levelStack = [];
 			continue;
 		}
-		if (!previousListItem) {
+		let depth = depthOf(block.level);
+		if (listDepthMap.set(block._key, depth), !previousListItem) {
 			let levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-			levelIndexMap.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, 1), previousListItem = {
+			levelIndexMap.set(depth, 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, 1), previousListItem = {
 				listItem: block.listItem,
-				level: block.level
+				depth
 			};
 			continue;
 		}
-		if (previousListItem.listItem === block.listItem && previousListItem.level < block.level) {
+		if (previousListItem.listItem === block.listItem && previousListItem.depth < depth) {
 			let levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-			levelIndexMap.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, 1), previousListItem = {
+			levelIndexMap.set(depth, 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, 1), previousListItem = {
 				listItem: block.listItem,
-				level: block.level
+				depth
 			};
 			continue;
 		}
 		levelIndexMaps.forEach((levelIndexMap, listItem) => {
 			if (listItem === block.listItem) return;
-			let levelsToDelete = [];
-			levelIndexMap.forEach((_, level) => {
-				level >= block.level && levelsToDelete.push(level);
-			}), levelsToDelete.forEach((level) => {
-				levelIndexMap.delete(level);
+			let depthsToDelete = [];
+			levelIndexMap.forEach((_, existingDepth) => {
+				existingDepth >= depth && depthsToDelete.push(existingDepth);
+			}), depthsToDelete.forEach((depthToDelete) => {
+				levelIndexMap.delete(depthToDelete);
 			});
 		});
-		let levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(block.level) ?? 0;
-		levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, levelCounter + 1), previousListItem = {
+		let levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(depth) ?? 0;
+		levelIndexMap.set(depth, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, levelCounter + 1), previousListItem = {
 			listItem: block.listItem,
-			level: block.level
+			depth
 		};
 	}
-	return listIndexMap;
+	return {
+		listIndexMap,
+		listDepthMap
+	};
 }
-const createRenderNode = (renderers, listIndexMap) => {
+const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
 	function renderNode(options) {
 		let { node, index, isInline } = options;
 		return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
@@ -99,6 +116,7 @@ const createRenderNode = (renderers, listIndexMap) => {
 			value: node,
 			index,
 			listIndex: node._key ? listIndexMap.get(node._key) : void 0,
+			listDepth: node._key ? listDepthMap.get(node._key) : void 0,
 			isInline: !1,
 			renderNode,
 			children
@@ -164,8 +182,8 @@ function serializeBlock(options) {
 /**
 * @public
 */
-const DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex }) => {
-	let listStyle = value.listItem || "bullet", level = value.level || 1, indent = "   ".repeat(level - 1);
+const DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex, listDepth }) => {
+	let listStyle = value.listItem || "bullet", depth = listDepth ?? (value.level || 1) - 1, indent = "   ".repeat(depth);
 	return listStyle === "number" ? `${indent}${listIndex ?? 1}. ${children}` : listStyle === "task" ? `${indent}- ${"checked" in value && typeof value.checked == "boolean" && value.checked ? "[x]" : "[ ]"} ${children}` : `${indent}- ${children}`;
 }, DefaultUnknownListItemRenderer = ({ children }) => `- ${children}\n`;
 /**
@@ -237,11 +255,75 @@ function uriLooksSafe(uri) {
 /**
 * @public
 */
-const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRenderer = ({ children }) => !children || children.trim() === "" ? "" : children, DefaultBlockquoteRenderer = ({ children }) => children ? children.split("\n").map((line) => `> ${line}`).join("\n") : ">", DefaultH1Renderer = ({ children }) => `# ${children}`, DefaultH2Renderer = ({ children }) => `## ${children}`, DefaultH3Renderer = ({ children }) => `### ${children}`, DefaultH4Renderer = ({ children }) => `#### ${children}`, DefaultH5Renderer = ({ children }) => `##### ${children}`, DefaultH6Renderer = ({ children }) => `###### ${children}`, DefaultUnknownStyleRenderer = ({ children }) => children ?? "", DefaultCodeBlockRenderer = ({ value }) => `\`\`\`${value.language ?? ""}\n${value.code}\n\`\`\``, DefaultHorizontalRuleRenderer = () => "---", DefaultHtmlRenderer = ({ value }) => value.html, DefaultImageRenderer = ({ value }) => {
-	let alt = escapeImageAndLinkText(value.alt ?? ""), title = value.title ? ` "${escapeImageAndLinkTitle(value.title)}"` : "";
-	return `![${alt}](${value.src}${title})`;
-}, DefaultTableRenderer = ({ value, renderNode }) => {
-	let rows = value.rows, alignment = value.alignment, headerRow = rows.at(0);
+const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRenderer = ({ children }) => !children || children.trim() === "" ? "" : children, DefaultBlockquoteRenderer = ({ children }) => children ? children.split("\n").map((line) => `> ${line}`).join("\n") : ">", DefaultH1Renderer = ({ children }) => `# ${children}`, DefaultH2Renderer = ({ children }) => `## ${children}`, DefaultH3Renderer = ({ children }) => `### ${children}`, DefaultH4Renderer = ({ children }) => `#### ${children}`, DefaultH5Renderer = ({ children }) => `##### ${children}`, DefaultH6Renderer = ({ children }) => `###### ${children}`, DefaultUnknownStyleRenderer = ({ children }) => children ?? "", DefaultCodeBlockRenderer = (options) => isCodeShaped(options.value) ? `\`\`\`${normalizeLanguage(options.value.language)}\n${options.value.code}\n\`\`\`` : DefaultUnknownTypeRenderer(options);
+function isCodeShaped(value) {
+	return typeof value?.code == "string";
+}
+/**
+* A fence info string is everything after the opening fence on the same
+* line, so a real `language` can never contain a newline, and the parser
+* only ever produces a string. Junk in this optional field should not send
+* an otherwise valid code block to the fenced-JSON path, so it is treated
+* as absent instead of guarded.
+*/
+function normalizeLanguage(language) {
+	return typeof language != "string" || language.includes("\n") ? "" : language;
+}
+/**
+* @public
+*/
+const DefaultHorizontalRuleRenderer = () => "---", DefaultHtmlRenderer = (options) => isHtmlShaped(options.value) ? options.value.html : DefaultUnknownTypeRenderer(options);
+function isHtmlShaped(value) {
+	return typeof value?.html == "string";
+}
+/**
+* @public
+*/
+const DefaultImageRenderer = (options) => {
+	if (!isImageShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	let alt = escapeImageAndLinkText(options.value.alt ?? ""), title = options.value.title ? ` "${escapeImageAndLinkTitle(options.value.title)}"` : "";
+	return `![${alt}](${options.value.src}${title})`;
+};
+function isImageShaped(value) {
+	let image = value;
+	return typeof image?.src == "string" && (image.alt == null || typeof image.alt == "string") && (image.title == null || typeof image.title == "string");
+}
+/**
+* A table is table-shaped when everything the renderer dereferences is
+* there: `rows` an array of typed objects with a `cells` array, every cell
+* a typed object whose `value` array holds typed objects (`renderNode`'s
+* input contract). The predicate narrows to exactly what `renderTable`
+* consumes, so the renderer needs no casts. A malformed `table` value
+* (e.g. a consumer's differently-shaped `table` type) falls back to the
+* fenced-JSON path instead of throwing.
+*/
+function isTableShaped(value) {
+	let rows = value?.rows;
+	return Array.isArray(rows) && rows.every((row) => isTypedObject(row) && Array.isArray(row.cells) && row.cells.every((cell) => isTypedObject(cell) && Array.isArray(cell.value) && cell.value.every(isTypedObject)));
+}
+/**
+* Renders a Portable Text table block-object back to Markdown.
+*
+* The PT `headerRows` field decides the header. Missing `headerRows` and
+* `headerRows === 0` both render headerless: GFM has no headerless form, so
+* an empty header row is emitted and every row goes in the body (that empty
+* header reads back as `headerRows: 0` via `markdownToPortableText`).
+* `headerRows >= 1` promotes `rows[0]` to the header. GFM allows exactly one
+* header row, so header rows beyond the first flatten into the body, lossy,
+* but the extra rows stay on the Portable Text side.
+*
+* Asymmetric tables (rows of varying cell counts) are widened to match
+* the row with the most cells. Narrower rows are padded with empty cells
+* so a GFM parser doesn't silently drop the extra cells in wider rows.
+*
+* @public
+*/
+const DefaultTableRenderer = (options) => {
+	let { value, renderNode } = options;
+	return isTableShaped(value) ? renderTable(value, renderNode) : DefaultUnknownTypeRenderer(options);
+};
+function renderTable(value, renderNode) {
+	let rows = value.rows, alignment = Array.isArray(value.alignment) ? value.alignment : void 0, headerRow = rows.at(0);
 	if (!headerRow) return "";
 	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => renderNode({
 		node: block,
@@ -256,33 +338,55 @@ const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRend
 		let align = alignment?.at(index);
 		return align === "left" ? " :--- " : align === "center" ? " :---: " : align === "right" ? " ---: " : " --- ";
 	}).join("|")}|`;
-	if (value.headerRows === 0) {
-		lines.push(renderCells([])), lines.push(delimiter);
-		for (let row of rows) lines.push(renderRow(row.cells));
-	} else {
+	if ((Number(value.headerRows) || 0) >= 1) {
 		lines.push(renderRow(headerRow.cells)), lines.push(delimiter);
 		for (let i = 1; i < rows.length; i++) {
 			let row = rows.at(i);
 			row && lines.push(renderRow(row.cells));
 		}
+	} else {
+		lines.push(renderCells([])), lines.push(delimiter);
+		for (let row of rows) lines.push(renderRow(row.cells));
 	}
 	return lines.join("\n");
-}, DefaultCalloutRenderer = ({ value, renderNode }) => {
-	let prefixed = value.content.map((block, index) => renderNode({
-		node: {
+}
+/**
+* @public
+*/
+const DefaultCalloutRenderer = (options) => {
+	if (!isCalloutShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	let { renderNode } = options, prefixed = options.value.content.map((block, index) => renderNode({
+		node: block._type === "block" ? {
 			...block,
 			style: "normal"
-		},
+		} : block,
 		index,
 		isInline: !1,
 		renderNode
 	})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
-	return `> [!${value.tone.toUpperCase()}]\n${prefixed}`;
-}, DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content.map((block, index) => renderNode({
-	node: {
+	return `> [!${options.value.tone.toUpperCase()}]\n${prefixed}`;
+};
+function isCalloutShaped(value) {
+	let callout = value;
+	return typeof callout?.tone == "string" && Array.isArray(callout.content) && callout.content.every(isTypedObject);
+}
+/**
+* Renders a structural blockquote block-object (the `types.blockquote` shape
+* produced by `markdownToPortableText` when a `types.blockquote` matcher is
+* provided) back to Markdown. Each content block is rendered via the
+* recursive renderer pipeline, joined with blank lines, and every line is
+* prefixed with `> ` to form a Markdown blockquote.
+*
+* Distinct from `DefaultBlockquoteRenderer`, which renders flat-path text
+* blocks with `style: 'blockquote'`.
+*
+* @public
+*/
+const DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content.map((block, index) => renderNode({
+	node: block._type === "block" ? {
 		...block,
 		style: "normal"
-	},
+	} : block,
 	index,
 	isInline: !1,
 	renderNode
@@ -314,7 +418,14 @@ const DefaultUnknownTypeRenderer = ({ value, isInline }) => {
 	let json = `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
 	return isInline ? `\n${json}\n` : json;
 }, defaultRenderers = {
-	types: {},
+	types: {
+		callout: DefaultCalloutRenderer,
+		code: DefaultCodeBlockRenderer,
+		"horizontal-rule": DefaultHorizontalRuleRenderer,
+		html: DefaultHtmlRenderer,
+		image: DefaultImageRenderer,
+		table: DefaultTableRenderer
+	},
 	block: {
 		normal: DefaultNormalRenderer,
 		blockquote: DefaultBlockquoteRenderer,
@@ -363,7 +474,7 @@ function portableTextToMarkdown(blocks, options = {}) {
 		unknownBlockStyle: options.unknownBlockStyle ?? defaultRenderers.unknownBlockStyle,
 		unknownListItem: options.unknownListItem ?? defaultRenderers.unknownListItem,
 		unknownMark: options.unknownMark ?? defaultRenderers.unknownMark
-	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, listIndexMap = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap);
+	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, { listIndexMap, listDepthMap } = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap, listDepthMap);
 	return blocks.map((node, index) => {
 		let renderedNode = renderNode({
 			node,
@@ -435,7 +546,24 @@ const normalStyleDefinition = { name: "normal" }, h1StyleDefinition = { name: "h
 		},
 		{
 			name: "rows",
-			type: "array"
+			type: "array",
+			of: [{
+				type: "object",
+				name: "row",
+				fields: [{
+					name: "cells",
+					type: "array",
+					of: [{
+						type: "object",
+						name: "cell",
+						fields: [{
+							name: "value",
+							type: "array",
+							of: [{ type: "block" }, { type: "image" }]
+						}]
+					}]
+				}]
+			}]
 		}
 	]
 }, defaultCalloutObjectDefinition = {
@@ -546,6 +674,13 @@ const codeBlockMatcher = ({ context, value, isInline }) => {
 		isInline
 	});
 	if (imageObject && "src" in imageObject) return imageObject;
+}, tableBlockMatcher = ({ context, value, isInline }) => {
+	let tableObject = buildObjectMatcher(defaultTableObjectDefinition)({
+		context,
+		value,
+		isInline
+	});
+	if (tableObject && "rows" in tableObject) return tableObject;
 }, defaultOptions = {
 	schema: defaultSchema,
 	keyGenerator: defaultKeyGenerator,
@@ -577,7 +712,8 @@ const codeBlockMatcher = ({ context, value, isInline }) => {
 		horizontalRule: buildObjectMatcher(defaultHorizontalRuleObjectDefinition),
 		html: buildObjectMatcher(defaultHtmlObjectDefinition),
 		image: imageBlockMatcher,
-		callout: buildObjectMatcher(defaultCalloutObjectDefinition)
+		callout: buildObjectMatcher(defaultCalloutObjectDefinition),
+		table: tableBlockMatcher
 	}
 };
 /**